import 'dart:developer' as developer;
import 'dart:async';
import 'dart:convert';
import 'package:get/get.dart';
import 'package:get_storage/get_storage.dart';
import 'package:rongcloud_im_wrapper_plugin/rongcloud_im_wrapper_plugin.dart';
import 'user_service.dart';
import 'notification_service.dart';
import 'app_lifecycle_service.dart'; // 🔥 导入App生命周期服务
import 'notification_manager.dart'; // 🔥 导入通知管理器
import '../utils/smart_notification_util.dart'; // 🔥 重新导入智能通知工具

import '../../pages/my/my_index/controller.dart'; // 导入MyIndexController
import '../../pages/home/controller.dart'; // 🔥 导入HomeController
import '../../pages/message/message_index/controller.dart'; // 🔥 导入MessageIndexController
import '../../pages/system/main/controller.dart'; // 🔥 导入MainController

// 使用融云官方插件类型定义
// 消息监听器回调类型
typedef MessageReceivedCallback = void Function(RCIMIWMessage? message, int? left, bool? hasPackage, bool? offline);
typedef ConnectionStatusChangedCallback = void Function(int? status);

/// 融云IM服务封装
/// 使用新版 rongcloud_im_wrapper_plugin
/// 🔥 参考MyApplication2架构实现统一管理
class RongCloudService extends GetxService {
static RongCloudService get to => Get.find();

  // 融云连接状态（全局唯一状态源）
  final RxBool isConnected = false.obs;
  final RxBool isConnecting = false.obs;
  
  // 🔥 连接锁：防止并发连接（参考MyApplication2架构）
  bool _isConnectLocked = false;
  
  // 融云配置信息（与MyApplication2保持一致）
  static const String appKey = "x4vkb1qpx8r4k"; // 融云生产环境AppKey
  
  // 融云引擎实例
  RCIMIWEngine? engine;
  
  // 消息监听器回调
  MessageReceivedCallback? onMessageReceived;
  ConnectionStatusChangedCallback? onConnectionStatusChanged;
  
  // 🔥 消息流控制器（供聊天页面监听）
  final StreamController<RCIMIWMessage> _messageStreamController = StreamController<RCIMIWMessage>.broadcast();
  
  /// 🔥 公开的消息流，供聊天页面监听
  Stream<RCIMIWMessage> get messageStream => _messageStreamController.stream;
  
  // 🔥 新增：新消息缓存（存储有新消息的用户ID）
  final RxSet<String> newMessageUserIds = <String>{}.obs;
  
  // 🔥 新增：消息详情缓存（存储最新消息内容，用于显示）
  final RxMap<String, Map<String, dynamic>> cachedMessages = <String, Map<String, dynamic>>{}.obs;
  
  // 🔥 新增：消息数量缓存（存储每个用户的未读消息数量）
  final RxMap<String, int> unreadMessageCounts = <String, int>{}.obs;
  
  // 🔥 新增：按用户ID分组的消息列表（核心架构）
  final RxMap<String, RxList<Map<String, dynamic>>> userMessages = <String, RxList<Map<String, dynamic>>>{}.obs;
  
  // 🔥 新增：好友申请通知状态（存储是否有待处理的好友申请）
  final RxBool hasPendingFriendRequest = false.obs;

  @override
  Future<void> onInit() async {
    super.onInit();
    await _initRongCloud();
    
    // 🔥 从本地存储恢复好友申请通知状态
    _restoreFriendRequestNotificationState();
  }
  
  /// 🔥 新增：从本地存储恢复好友申请通知状态
  void _restoreFriendRequestNotificationState() {
    try {
      final storage = GetStorage();
      final savedState = storage.read<bool>('hasPendingFriendRequest') ?? false;
      hasPendingFriendRequest.value = savedState;
      developer.log('✅ 从本地存储恢复好友申请状态: $savedState');
    } catch (e) {
      developer.log('💥 恢复好友申请状态异常: $e');
      hasPendingFriendRequest.value = false;
    }
  }

  /// 初始化融云SDK（增强版本）
  Future<void> _initRongCloud() async {
    try {
      developer.log('🚀 初始化融云SDK...');
      
      // 创建融云引擎
      RCIMIWEngineOptions options = RCIMIWEngineOptions.create();
      engine = await RCIMIWEngine.create(appKey, options);
      
      if (engine == null) {
        developer.log('❌ 融云引擎创建失败');
        return;
      }
      
      // 设置监听器
      _setupEngineListeners();
      
      developer.log('✅ 融云SDK初始化完成');
      
    } catch (e) {
      developer.log('💥 融云SDK初始化异常: $e');
    }
  }

  /// 🔥 统一连接入口（参考MyApplication2的connectIM方法）
  /// 这是全局唯一的连接方法，所有页面都应该调用这个方法
  Future<bool> connectIM({bool forceReconnect = false}) async {
    // 🔥 连接锁检查：防止并发连接
    if (_isConnectLocked && !forceReconnect) {
      developer.log('⚠️ 连接正在进行中，等待当前连接完成');
      return await _waitForCurrentConnection();
    }
    
    // 🔥 状态检查：已连接则直接返回
    if (isConnected.value && !forceReconnect) {
      developer.log('✅ 融云已连接，无需重复连接');
      return true;
    }
    
    // 🔥 设置连接锁
    _isConnectLocked = true;
    
    try {
      return await _performConnection(forceReconnect);
    } finally {
      _isConnectLocked = false;
    }
  }
  
  /// 🔥 执行实际的连接操作（内部方法）
  Future<bool> _performConnection(bool forceReconnect) async {
    try {
      developer.log('🚀 =============== 开始融云连接流程 ===============');
      
      // 🔥 1. 强化连接状态检查 - 先检查真实连接状态
      if (!forceReconnect) {
        // 检查是否正在连接中
        if (isConnecting.value) {
          developer.log('⚠️ 融云正在连接中，跳过重复连接请求');
          return await _waitForConnectionResult(); // 等待当前连接完成
        }
        
        // 检查是否已经连接成功
        if (isConnected.value) {
          developer.log('✅ 融云已连接，无需重复连接');
          return true;
        }
      }
      
      final userService = UserService.to;
      
      // 2. 检查引擎状态
      if (engine == null) {
        developer.log('❌ 融云引擎未初始化');
        await _initRongCloud(); // 尝试重新初始化
        if (engine == null) {
          return false;
        }
      }
      
      // 3. 检查用户登录状态
      if (!userService.isLoggedIn) {
        developer.log('❌ 用户未登录');
        return false;
      }
      
      // 4. 检查Token有效性
      final token = userService.rongCloudToken;
      if (token == null || token.isEmpty) {
        developer.log('❌ 融云Token为空');
        return false;
      }
      
      if (token.length < 20) {
        developer.log('❌ 融云Token格式异常，长度: ${token.length}');
        return false;
      }
      
      developer.log('🔍 连接前状态检查:');
      developer.log('   引擎状态: ${engine != null ? "已初始化" : "未初始化"}');
      developer.log('   当前连接状态: ${isConnected.value}');
      developer.log('   当前连接中状态: ${isConnecting.value}');
      developer.log('   用户ID: ${userService.userId}');
      developer.log('   Token长度: ${token.length}');
      developer.log('   Token前缀: ${token.substring(0, 20)}...');
      
      // 🔥 5. 强制重连处理 - 先彻底断开
      if (forceReconnect) {
        developer.log('🔄 强制重连：先彻底断开现有连接');
        await disconnect();
        // 🔥 等待更长时间确保完全断开
        await Future.delayed(const Duration(milliseconds: 1000));
        
        // 🔥 重新初始化引擎（解决34001问题的关键）
        await _reinitializeSDK();
        await Future.delayed(const Duration(milliseconds: 500));
      }
      
      // 6. 设置连接状态（使用原子操作避免竞态）
      if (isConnecting.value) {
        developer.log('⚠️ 检测到并发连接请求，取消当前请求');
        return false;
      }
      
      isConnecting.value = true;
      isConnected.value = false;
      
      developer.log('🔗 发起融云连接请求...');
      
      try {
        // 7. 连接融云
        int? ret = await engine!.connect(token, 10); // 降低超时时间到10秒
        
        developer.log('📋 连接请求返回码: $ret');
        
        if (ret == 0) {
          developer.log('✅ 融云连接请求已发送成功');
          
          // 🔥 等待连接回调，最多等待5秒
          final connectionResult = await _waitForConnectionCallback();
          
          if (connectionResult) {
            developer.log('🎉 融云连接并回调成功');
            return true;
          } else {
            developer.log('⚠️ 连接请求成功但回调超时');
            return false;
          }
        } else {
          developer.log('❌ 融云连接请求失败: $ret');
          await _handleConnectionError(ret);
          return false;
        }
      } catch (e) {
        developer.log('💥 融云连接请求异常: $e');
        await _handleConnectionError(null);
        return false;
      }
      
    } catch (e) {
      developer.log('💥 融云连接流程异常: $e');
      isConnected.value = false;
      return false;
    } finally {
      isConnecting.value = false;
      developer.log('🏁 =============== 融云连接流程结束 ===============');
    }
  }
  
  /// 🔥 等待当前连接完成（避免重复连接）
  Future<bool> _waitForCurrentConnection() async {
    int waitCount = 0;
    const maxWaitTime = 10; // 最多等待10秒
    
    while (_isConnectLocked && waitCount < maxWaitTime) {
      await Future.delayed(const Duration(seconds: 1));
      waitCount++;
      
      // 如果连接成功了，直接返回
      if (isConnected.value) {
        developer.log('✅ 等待期间连接成功');
        return true;
      }
    }
    
    if (waitCount >= maxWaitTime) {
      developer.log('⚠️ 等待连接超时');
      return false;
    }
    
    return isConnected.value;
  }
  
  /// 🔥 新增：等待当前连接完成
  Future<bool> _waitForConnectionResult() async {
    final maxWaitTime = 5; // 最多等待5秒
    for (int i = 0; i < maxWaitTime * 2; i++) {
      if (!isConnecting.value) {
        return isConnected.value;
      }
      await Future.delayed(const Duration(milliseconds: 500));
    }
    return false;
  }
  
  /// 🔥 新增：等待连接状态回调
  Future<bool> _waitForConnectionCallback() async {
    final maxWaitTime = 5; // 最多等待5秒
    for (int i = 0; i < maxWaitTime * 4; i++) {
      if (isConnected.value) {
        return true;
      }
      await Future.delayed(const Duration(milliseconds: 250));
    }
    return false;
  }

  /// 处理连接错误
  Future<void> _handleConnectionError(int? errorCode) async {
    isConnected.value = false;
    isConnecting.value = false;
    
    switch (errorCode) {
      case 34001:
        developer.log('🔧 错误34001处理：客户端未正确初始化');
        // 尝试重新初始化SDK
        await Future.delayed(const Duration(milliseconds: 1000));
        await _reinitializeSDK();
        break;
      case 33003:
        developer.log('🔧 错误33003处理：Token无效');
        break;
      case 34002:
        developer.log('🔧 错误34002处理：网络不可用');
        break;
      default:
        developer.log('🔧 未知错误码: $errorCode');
        break;
    }
  }

  /// 重新初始化SDK（解决34001问题）
  Future<void> _reinitializeSDK() async {
    try {
      developer.log('🔄 开始重新初始化融云SDK...');
      
      // 🔥 1. 先彻底断开现有连接
      if (engine != null) {
        try {
          await engine!.disconnect(true);
          developer.log('✅ 现有连接已断开');
        } catch (e) {
          developer.log('⚠️ 断开连接异常（继续重新初始化）: $e');
        }
      }
      
      // 🔥 2. 重置连接状态
      isConnected.value = false;
      isConnecting.value = false;
      
      // 🔥 3. 销毁现有引擎
      try {
        if (engine != null) {
          await engine!.destroy();
          developer.log('✅ 现有引擎已销毁');
        }
      } catch (e) {
        developer.log('⚠️ 销毁引擎异常（继续重新初始化）: $e');
      }
      
      // 🔥 4. 等待一下确保资源完全释放
      await Future.delayed(const Duration(milliseconds: 200));
      
      // 🔥 5. 重新创建引擎
      RCIMIWEngineOptions options = RCIMIWEngineOptions.create();
      engine = await RCIMIWEngine.create(appKey, options);
      
      if (engine != null) {
        // 重新设置监听器
        _setupEngineListeners();
        developer.log('✅ 融云SDK重新初始化完成');
      } else {
        developer.log('❌ 融云SDK重新初始化失败 - 引擎创建返回null');
      }
      
    } catch (e) {
      developer.log('💥 重新初始化SDK异常: $e');
      // 🔥 确保异常情况下状态也正确重置
      isConnected.value = false;
      isConnecting.value = false;
      engine = null;
    }
  }

  /// 设置引擎监听器
  void _setupEngineListeners() {
    if (engine == null) return;
    
    // 设置消息接收监听器
    engine!.onMessageReceived = (
      RCIMIWMessage? message,
      int? left,
      bool? offline,
      bool? hasPackage,
    ) {
      developer.log('📥 收到消息: offline=$offline');
      _handleReceivedMessage(message, offline ?? false);
      
      // 🔥 将消息发送到流中，供聊天页面监听
      if (message != null) {
        _messageStreamController.add(message);
      }
      
      if (onMessageReceived != null) {
        onMessageReceived!(message, left, hasPackage, offline);
      }
    };
    
    // 设置连接状态监听器
    engine!.onConnected = (int? code, String? userId) {
      developer.log('🔗 融云连接状态回调: code=$code, userId=$userId');
      if (code == 0) {
        isConnected.value = true;
        isConnecting.value = false;
        developer.log('✅ 融云连接成功');
      } else {
        isConnected.value = false;
        isConnecting.value = false;
        developer.log('❌ 融云连接失败回调: $code');
        _handleConnectionError(code);
      }
    };
  }

  /// 断开连接
  Future<void> disconnect() async {
    try {
      developer.log('🔄 断开融云连接...');
      
      // 🔥 重置连接锁
      _isConnectLocked = false;
      
      if (engine != null) {
        int? ret = await engine!.disconnect(true);
        developer.log('✅ 融云连接已断开: code=$ret');
      }
      isConnected.value = false;
      isConnecting.value = false;
    } catch (e) {
      developer.log('💥 断开融云连接异常: $e');
    }
  }
  
  /// 🔥 参考MyApplication2的setIMStatusListener，设置全局状态监听器
  void setIMStatusListener() {
    if (engine == null) {
      developer.log('⚠️ 融云引擎未初始化，无法设置状态监听器');
      return;
    }
    
    // 设置连接状态监听器（参考MyApplication2的connectionStatusListener）
    _setupEngineListeners();
    
    developer.log('✅ 全局IM状态监听器已设置');
  }
  
  /// 🔥 参考MyApplication2的receiveLogOutMessage，接收离线消息
  void receiveLogOutMessage() {
    if (engine == null) {
      developer.log('⚠️ 融云引擎未初始化，无法设置消息监听器');
      return;
    }
    
    // 设置消息接收监听器（参考MyApplication2的onReceiveMessageWrapperListener）
    _setupEngineListeners();
    
    developer.log('✅ 离线消息监听器已设置');
  }

  /// 发送文本消息（修复版本 - 智能连接检查和重试）
  Future<bool> sendTextMessage({
    required String targetId,
    required String content,
    RCIMIWConversationType conversationType = RCIMIWConversationType.private,
  }) async {
    try {
      if (engine == null) {
        developer.log('❌ 融云引擎未初始化');
        return false;
      }
      
      // 🔥 智能连接检查 - 等待连接或尝试连接
      if (!isConnected.value) {
        developer.log('⚠️ 融云未连接，检查连接状态...');
        
        // 如果正在连接中，等待连接完成
        if (isConnecting.value) {
          developer.log('⏳ 等待现有连接完成...');
          final waitResult = await _waitForConnectionCallback();
          if (!waitResult) {
            developer.log('❌ 等待连接超时');
            return false;
          }
        } else {
          // 尝试连接
          developer.log('🔄 尝试连接融云...');
          final connected = await connectIM();
          if (!connected) {
            developer.log('❌ 无法连接融云');
            return false;
          }
        }
        
        // 🔥 再次确认连接状态
        if (!isConnected.value) {
          developer.log('❌ 连接后状态仍为未连接');
          return false;
        }
      }
      
      developer.log('📤 发送消息: $content -> $targetId');
      
      // 创建文本消息
      RCIMIWTextMessage? textMessage = await engine!.createTextMessage(
        conversationType,
        targetId,
        '', // channelId
        content,
      );
      
      if (textMessage == null) {
        developer.log('❌ 创建消息失败');
        return false;
      }
      
      // 🔥 修复：添加用户信息到extra（参考MyApplication2的实现）
      await _setMessageExtra(textMessage);
      
      // 发送消息
      int? ret = await engine!.sendMessage(textMessage);
      
      if (ret == 0) {
        developer.log('✅ 消息发送成功');
        return true;
      } else {
        developer.log('❌ 消息发送失败: $ret');
        return false;
      }
      
    } catch (e) {
      developer.log('💥 发送消息异常: $e');
      return false;
    }
  }

  /// 🔥 新增：设置消息的extra数据（参考MyApplication2实现）
  Future<void> _setMessageExtra(RCIMIWTextMessage textMessage) async {
    try {
      final userService = UserService.to;
      
      // 构建extra数据，包含用户名和头像URL
      final extraData = <String, dynamic>{
        'userName': userService.userName.isNotEmpty ? userService.userName : '未知用户',
        'userAvatarUrl': userService.userAvatar.isNotEmpty ? userService.userAvatar : '',
      };
      
      // 转换为JSON字符串
      final extraJson = jsonEncode(extraData);
      
      // 设置extra到消息中
      textMessage.extra = extraJson;
      
      developer.log('📝 设置消息extra: $extraJson');
      
    } catch (e) {
      developer.log('💥 设置消息extra异常: $e');
    }
  }

  /// 获取聊天记录（使用新版API - 修复版本）
  Future<List<RCIMIWMessage>> getChatHistory({
    required String targetId,
    RCIMIWConversationType conversationType = RCIMIWConversationType.private,
    int count = 20,
  }) async {
    try {
      developer.log('📚 =============== 获取融云聊天记录 ===============');
      developer.log('🎯 目标用户ID: $targetId');
      developer.log('📊 获取数量: $count');
      developer.log('🔗 会话类型: $conversationType');
      
      if (engine == null) {
        developer.log('❌ 融云引擎未初始化');
        return [];
      }
      
      if (!isConnected.value) {
        developer.log('❌ 融云未连接');
        return [];
      }
      
      try {
        // 🔥 使用正确的API获取消息列表
        developer.log('🔄 尝试调用融云getMessages API...');
        
        // 🔥 直接尝试获取消息，不检查会话（简化处理）
        // 注意：由于融云API的复杂性和回调机制，这里采用保守策略
        developer.log('⚠️ 融云getMessages API使用回调机制，当前版本暂不支持直接获取');
        developer.log('💡 将依赖缓存消息和本地存储作为主要数据源');
        
        // 🔥 作为替代方案，检查是否有缓存的消息
        if (cachedMessages.containsKey(targetId)) {
          developer.log('📥 找到目标用户的缓存消息');
          final cachedMessage = getLatestMessage(targetId);
          if (cachedMessage != null) {
            // 由于无法直接构造RCIMIWMessage对象，返回空列表
            // 让调用方从缓存和本地存储获取消息
            developer.log('✅ 有缓存消息可用，但API限制无法直接转换');
          }
        }
        
        return []; // 当前版本暂时返回空列表，依赖缓存机制
        
      } catch (apiError) {
        developer.log('💥 调用融云API异常: $apiError');
        return [];
      }
      
    } catch (e) {
      developer.log('💥 获取聊天记录异常: $e');
      return [];
    } finally {
      developer.log('📚 =============== 聊天记录获取结束 ===============');
    }
  }



  /// 清除聊天记录（使用新版API）
  Future<bool> clearChatHistory({
    required String targetId,
    RCIMIWConversationType conversationType = RCIMIWConversationType.private,
  }) async {
    try {
      developer.log('🗑️ 清除聊天记录: $targetId');
      
      if (engine == null) {
        developer.log('⚠️ 融云引擎未初始化');
        return false;
      }
      
      int? ret = await engine!.clearMessages(
        conversationType,
        targetId,
        '',     // channelId
        0,      // timestamp
        RCIMIWMessageOperationPolicy.local,  // policy
      );
      
      if (ret == 0) {
        developer.log('✅ 聊天记录清除成功');
        return true;
      } else {
        developer.log('❌ 聊天记录清除失败: code=$ret');
        return false;
      }
      
    } catch (e) {
      developer.log('💥 清除聊天记录异常: $e');
      return false;
    }
  }

  // 移除复杂的Token过期处理，回到简化版本

  /// 销毁融云引擎
  Future<void> destroy() async {
    try {
      if (engine != null) {
        await engine!.destroy();
        engine = null;
        developer.log('✅ 融云引擎已销毁');
      }
    } catch (e) {
      developer.log('💥 销毁融云引擎异常: $e');
    }
  }

  /// 处理接收到的消息（参考MyApplication2的消息处理逻辑）
  void _handleReceivedMessage(RCIMIWMessage? message, bool isOffline) {
    try {
      if (message == null) return;
      
      developer.log('🔄 处理接收到的消息...');
      
      // 获取消息内容
      String? content;
      String? senderName;
      
      // 解析消息内容（参考MyApplication2的JSON解析）
      if (message is RCIMIWTextMessage) {
        final textMessage = message;
        content = textMessage.text;
        
        // 尝试解析extra中的用户信息
        if (textMessage.extra?.isNotEmpty == true) {
          try {
            final extraData = jsonDecode(textMessage.extra!);
            senderName = extraData['userName'] ?? '';
          } catch (e) {
            developer.log('解析消息extra异常: $e');
          }
        }
      }
      
      if (content?.isEmpty == true) return;
      
      developer.log('消息内容: $content');
      developer.log('发送者: $senderName');
      
      // 🔥 解析消息extra数据
      Map<String, dynamic>? extraData;
      if (message.extra?.isNotEmpty == true) {
        try {
          extraData = jsonDecode(message.extra!);
          developer.log('📊 解析消息extra成功: $extraData');
        } catch (e) {
          developer.log('⚠️ 解析消息extra失败: $e');
        }
      }

      // 根据消息内容类型分类处理（参考MyApplication2的分类逻辑）
      if (content!.contains('***')) {
        // 活动申请相关消息（参考MyApplication2的活动申请处理）
        _handleActivityMessage(content, senderName, message.senderUserId, messageExtra: extraData); // 🔥 传递真实发送者ID
      } else if (content == _getAddFriendToastMessage()) {
        // 好友申请消息（参考MyApplication2的好友申请处理）
        _handleFriendRequestMessage(senderName, message.senderUserId, messageExtra: extraData); // 🔥 传递真实发送者ID
      } else {
        // 普通聊天消息（参考MyApplication2的聊天消息处理）
        _handleChatMessage(content, senderName, message.senderUserId, message: message, messageExtra: extraData); // 🔥 传递完整的message对象
      }
      
    } catch (e) {
      developer.log('💥 处理消息异常: $e');
    }
  }

  /// 处理活动申请消息（参考MyApplication2的活动申请处理）
  void _handleActivityMessage(String content, String? senderName, String? senderId, {Map<String, dynamic>? messageExtra}) async {
    try {
      developer.log('🎯 处理活动申请消息');
      
      // 移除消息标识符（参考MyApplication2的substring处理）
      String displayContent = content.substring(0, content.length - 3);
      
      // 🔥 从消息extra中提取用户信息
      String finalSenderName = senderName ?? '未知用户';
      String senderAvatar = '';
      String finalSenderId = senderId ?? 'unknown';
      
      if (messageExtra != null) {
        finalSenderName = messageExtra['userName'] ?? finalSenderName;
        senderAvatar = messageExtra['userAvatarUrl'] ?? '';
        developer.log('📨 从消息extra中获取用户信息: $finalSenderName, 头像: ${senderAvatar.isNotEmpty ? "已获取" : "无头像"}');
      }
      
      // 🔥 **新功能：将活动申请消息也存入聊天历史**
      // 参考MyApplication2的设计，让系统消息在聊天页面中以特殊样式显示
      try {
        // 🔥 获取真实用户ID（从融云用户ID映射到数据库用户ID）
        String databaseUserId = _convertRongCloudUserIdToDatabaseUserId(finalSenderId);
        
        developer.log('🎯 活动申请消息存储信息:');
        developer.log('   融云发送者ID: $finalSenderId');
        developer.log('   数据库用户ID: $databaseUserId');
        developer.log('   发送者姓名: $finalSenderName');
        
        // 🔥 添加到统一消息管理系统，标记为系统消息
        addMessageToUser(
          userId: databaseUserId,
          content: '🎯 $finalSenderName 申请参加活动：$displayContent',
          isMe: false,
          timestamp: DateTime.now(),
          messageId: 'activity_${DateTime.now().millisecondsSinceEpoch}',
          senderName: finalSenderName,
          senderAvatar: senderAvatar,
          messageType: 'activity_request', // 🔥 新增：消息类型标识
        );
        
        developer.log('✅ 活动申请消息已存入聊天历史: $databaseUserId');
        
        // 🔥 同时保留原有缓存逻辑（用于聊天列表显示）
        _cacheNewMessage(databaseUserId, '申请参加活动：$displayContent', finalSenderName, senderAvatar);
      } catch (e) {
        developer.log('💥 保存活动申请消息到聊天历史异常: $e');
      }
      
      // 🔥 新增：打印极光推送的详细配置和日志信息（活动申请）
      try {
        await _printJPushDetailedLogs(
          senderName: finalSenderName,
          messageContent: '申请参加活动：$displayContent',
          senderUserId: finalSenderId,
        );
        developer.log('✅ 活动申请极光推送详细日志打印完成');
      } catch (e) {
        developer.log('💥 打印活动申请极光推送详细日志异常: $e');
      }
      
      // 🔥 根据app前台/后台状态决定通知方式
      final lifecycleService = AppLifecycleService.to;
      final shouldShowSystemNotification = lifecycleService.shouldShowSystemNotification();
      
      if (shouldShowSystemNotification) {
        // 后台：使用极光推送发送活动申请通知
        developer.log('📱 App在后台，使用极光推送发送活动申请通知');
        await NotificationService.to.sendJPushBackgroundNotification(
          title: '活动申请',
          body: '$finalSenderName 申请参加活动：$displayContent',
          payload: 'jpush_activity_request',
          userId: 'activity_request', // 🔥 活动申请使用固定ID
        );
      } else {
        // 前台：显示app内顶部弹出框通知
        developer.log('📱 App在前台，显示内部通知');
        await SmartNotificationUtil.instance.handleMessageNotification(
          senderUserId: 'activity_request', // 特殊标识为活动申请
          senderName: finalSenderName,
          senderAvatar: senderAvatar,
          messageContent: '申请参加活动：$displayContent', // 固定消息内容格式
          currentChatUserId: null,
        );
      }
      
      // 📝 设置活动申请通知状态，显示小黄点（参考MyApplication2的ifInputActivity逻辑）
      _setActivityApplicationNotification(true);
      
      // 🔥 设置主页消息通知小红点
      _setHomeMessageNotification(true);
      
      developer.log('✅ 活动申请通知处理完成（${shouldShowSystemNotification ? "HEAD_UP通知" : "内部通知"}+聊天记录+小红点）');
      
    } catch (e) {
      developer.log('💥 处理活动申请消息异常: $e');
    }
  }

  /// 处理好友申请消息（参考MyApplication2的好友申请处理）
  void _handleFriendRequestMessage(String? senderName, String? senderId, {Map<String, dynamic>? messageExtra}) async {
    try {
      developer.log('👥 处理好友申请消息');
      
      // 🔥 从消息extra中提取用户信息
      String finalSenderName = senderName ?? '未知用户';
      String senderAvatar = '';
      String finalSenderId = senderId ?? 'unknown';
      
      if (messageExtra != null) {
        finalSenderName = messageExtra['userName'] ?? finalSenderName;
        senderAvatar = messageExtra['userAvatarUrl'] ?? '';
        developer.log('📨 从消息extra中获取用户信息: $finalSenderName, 头像: ${senderAvatar.isNotEmpty ? "已获取" : "无头像"}');
      }
      
      // 🔥 **新功能：将好友申请消息也存入聊天历史**
      // 参考MyApplication2的设计，让系统消息在聊天页面中以特殊样式显示
      try {
        // 🔥 获取真实用户ID（从融云用户ID映射到数据库用户ID）
        String databaseUserId = _convertRongCloudUserIdToDatabaseUserId(finalSenderId);
        
        developer.log('👥 好友申请消息存储信息:');
        developer.log('   融云发送者ID: $finalSenderId');
        developer.log('   数据库用户ID: $databaseUserId');
        developer.log('   发送者姓名: $finalSenderName');
        
        // 🔥 添加到统一消息管理系统，标记为系统消息
        addMessageToUser(
          userId: databaseUserId,
          content: '👥 $finalSenderName 发送了好友申请',
          isMe: false,
          timestamp: DateTime.now(),
          messageId: 'friend_${DateTime.now().millisecondsSinceEpoch}',
          senderName: finalSenderName,
          senderAvatar: senderAvatar,
          messageType: 'friend_request', // 🔥 新增：消息类型标识
        );
        
        developer.log('✅ 好友申请消息已存入聊天历史: $databaseUserId');
        
        // 🔥 同时保留原有缓存逻辑（用于聊天列表显示）
        _cacheNewMessage(databaseUserId, '发送了好友申请', finalSenderName, senderAvatar);
      } catch (e) {
        developer.log('💥 保存好友申请消息到聊天历史异常: $e');
      }
      
      // 🔥 新增：打印极光推送的详细配置和日志信息（好友申请）
      try {
        await _printJPushDetailedLogs(
          senderName: finalSenderName,
          messageContent: '发送了好友申请',
          senderUserId: finalSenderId,
        );
        developer.log('✅ 好友申请极光推送详细日志打印完成');
      } catch (e) {
        developer.log('💥 打印好友申请极光推送详细日志异常: $e');
      }
      
      // 🔥 根据app前台/后台状态决定通知方式
      final lifecycleService = AppLifecycleService.to;
      final shouldShowSystemNotification = lifecycleService.shouldShowSystemNotification();
      
      if (shouldShowSystemNotification) {
        // 后台：使用极光推送发送好友申请通知
        developer.log('📱 App在后台，使用极光推送发送好友申请通知');
        await NotificationService.to.sendJPushBackgroundNotification(
          title: '好友申请',
          body: '收到来自 $finalSenderName 的好友申请',
          payload: 'jpush_friend_request',
          userId: 'friend_request', // 🔥 好友申请使用固定ID
        );
      } else {
        // 前台：显示app内顶部弹出框通知
        developer.log('📱 App在前台，显示内部通知');
        await SmartNotificationUtil.instance.handleMessageNotification(
          senderUserId: 'friend_request', // 特殊标识为好友申请
          senderName: finalSenderName,
          senderAvatar: senderAvatar,
          messageContent: '发送了好友申请', // 固定消息内容
          currentChatUserId: null,
        );
      }
      
      // 🔥 设置加好友消息通知状态（统一管理主页和聊天页面）
      _setFriendRequestNotification(true);
      
      // 🔥 设置融云服务中的好友申请状态
      hasPendingFriendRequest.value = true;
      developer.log('🔔 融云服务中的好友申请状态已设置: true');
      
      // 🔥 同步状态到本地存储
      try {
        final storage = GetStorage();
        storage.write('hasPendingFriendRequest', true);
        developer.log('✅ 好友申请状态已同步到本地存储: true');
      } catch (storageError) {
        developer.log('⚠️ 同步好友申请状态到本地存储失败: $storageError');
      }
      
      developer.log('✅ 好友申请通知处理完成（${shouldShowSystemNotification ? "极光推送通知" : "内部通知"}+聊天记录+小黄点）');
      
    } catch (e) {
      developer.log('💥 处理好友申请消息异常: $e');
    }
  }

  /// 处理普通聊天消息（参考MyApplication2的聊天消息处理）
  void _handleChatMessage(String content, String? senderName, String? senderId, {RCIMIWMessage? message, Map<String, dynamic>? messageExtra}) async {
    try {
      developer.log('💬 处理聊天消息');
      
      // 🔥 从消息extra中提取更完整的用户信息
      String finalSenderName = senderName ?? '未知用户';
      String senderAvatar = '';
      String finalSenderId = senderId ?? 'unknown';
      
      if (messageExtra != null) {
        finalSenderName = messageExtra['userName'] ?? finalSenderName;
        senderAvatar = messageExtra['userAvatarUrl'] ?? '';
        developer.log('📨 从消息extra中获取用户信息: $finalSenderName, 头像: ${senderAvatar.isNotEmpty ? "已获取" : "无头像"}');
      }
      
      // 🔥 新增：打印极光推送的详细配置和日志信息
      try {
        await _printJPushDetailedLogs(
          senderName: finalSenderName,
          messageContent: content,
          senderUserId: finalSenderId,
        );
        developer.log('✅ 极光推送详细日志打印完成');
      } catch (e) {
        developer.log('💥 打印极光推送详细日志异常: $e');
      }
      
      // 🔥 需要将融云用户ID转换为数据库用户ID进行通知
      // 从融云用户ID (手机号) 推断数据库用户ID
      String databaseUserId = _convertRongCloudUserIdToDatabaseUserId(finalSenderId);
      
      // 🔥 新架构：将消息添加到统一消息管理系统
      addMessageToUser(
        userId: databaseUserId,
        content: content,
        isMe: false,
        timestamp: DateTime.fromMillisecondsSinceEpoch(message?.sentTime ?? DateTime.now().millisecondsSinceEpoch),
        messageId: message?.messageId?.toString(),
        senderName: finalSenderName,
        senderAvatar: senderAvatar,
        messageType: 'chat', // 🔥 普通聊天消息类型
      );
      
      // 🔥 保留原有缓存逻辑（用于聊天列表显示）
      _cacheNewMessage(databaseUserId, content, finalSenderName, senderAvatar);
      
      // 🔥 根据app前台/后台状态决定通知方式
      final lifecycleService = AppLifecycleService.to;
      final shouldShowSystemNotification = lifecycleService.shouldShowSystemNotification();
      
      if (shouldShowSystemNotification) {
        // 后台：使用极光推送发送状态栏通知
        developer.log('📱 App在后台，使用极光推送发送通知');
        await NotificationService.to.sendJPushBackgroundNotification(
          title: finalSenderName,
          body: content,
          payload: 'jpush_chat_$databaseUserId',
          userId: databaseUserId, // 🔥 添加用户ID，实现消息合并
        );
      } else {
        // 前台：显示app内通知（使用智能通知系统判断是否需要显示）
        developer.log('📱 App在前台，使用智能通知系统');
        await SmartNotificationUtil.instance.handleMessageNotification(
          senderUserId: databaseUserId, // 🔥 使用数据库用户ID，确保与聊天页面的ID匹配
          senderName: finalSenderName,
          senderAvatar: senderAvatar, // 🔥 使用从extra中提取的头像
          messageContent: content,
          currentChatUserId: null, // 全局层面无当前聊天用户概念，由智能系统判断
          messageId: message?.messageId?.toString(), // 🔥 传递消息ID用于去重
        );
      }
      
      // 🔥 设置主页消息通知小红点
      _setHomeMessageNotification(true);
      
      developer.log('📝 消息已接收并处理通知: $finalSenderName - $content（${shouldShowSystemNotification ? "极光推送通知" : "智能通知"}）');
      
    } catch (e) {
      developer.log('💥 处理聊天消息异常: $e');
    }
  }

  /// 🔥 将融云用户ID转换为数据库用户ID
  /// 融云用户ID通常是手机号，需要映射到数据库用户ID
  String _convertRongCloudUserIdToDatabaseUserId(String rongCloudUserId) {
    developer.log('🔄 =============== 融云用户ID映射 ===============');
    developer.log('📱 输入的融云用户ID: $rongCloudUserId');
    
    // 🔥 扩展映射关系，包含从日志中观察到的映射
    const rongCloudToDbUserIdMap = {
      '13482276617': '57',  // 面包树的映射关系
      '15527877711': '3',   // 武汉玩真的的映射关系
      '15556789096': '242', // 🔥 新增：用户9096的映射关系（从日志中发现）
      '13817024502': '2',   // 🔥 新增：酱酱的映射关系
    };
    
    // 查找映射
    String? mappedUserId = rongCloudToDbUserIdMap[rongCloudUserId];
    
    if (mappedUserId != null) {
      developer.log('✅ 找到映射关系: $rongCloudUserId → $mappedUserId');
      return mappedUserId;
    } else {
      developer.log('⚠️ 未找到映射关系，使用原始ID: $rongCloudUserId');
      developer.log('💡 建议添加映射关系到rongCloudToDbUserIdMap');
      
      // 🔥 新增：尝试从好友列表中动态查找映射关系
      String? dynamicMappedId = _findUserIdFromFriendList(rongCloudUserId);
      if (dynamicMappedId != null) {
        developer.log('🔍 从好友列表找到动态映射: $rongCloudUserId → $dynamicMappedId');
        return dynamicMappedId;
      }
      
      return rongCloudUserId; // 如果没有映射关系，直接返回原ID
    }
  }
  
  /// 🔥 新增：从好友列表中动态查找用户ID映射
  String? _findUserIdFromFriendList(String phoneNumber) {
    try {
      // 尝试从MessageIndexController获取好友列表
      if (Get.isRegistered<MessageIndexController>()) {
        final messageController = Get.find<MessageIndexController>();
        final friendList = messageController.friendList;
        
        // 在好友列表中查找手机号匹配的用户
        for (final friend in friendList) {
          if (friend.userPhone == phoneNumber) {
            developer.log('🔍 在好友列表中找到匹配用户: ${friend.username} (ID: ${friend.friendId})');
            return friend.friendId.toString();
          }
        }
      }
      
      developer.log('⚠️ 在好友列表中未找到手机号 $phoneNumber 对应的用户');
      return null;
    } catch (e) {
      developer.log('💥 动态查找用户ID映射异常: $e');
      return null;
    }
  }

  /// 获取好友申请提示消息（参考MyApplication2的showAddFriendToast方法）
  String _getAddFriendToastMessage() {
    return "收到一条新的好友申请";
  }

  /// 发送好友申请推送（参考MyApplication2的showAddFriendWithRongCloud方法）
  Future<bool> sendFriendRequestMessage(String targetUserId) async {
    try {
      developer.log('📤 发送好友申请推送到: $targetUserId');
      
      return await sendTextMessage(
        targetId: targetUserId,
        content: _getAddFriendToastMessage(),
        conversationType: RCIMIWConversationType.private,
      );
    } catch (e) {
      developer.log('💥 发送好友申请异常: $e');
      return false;
    }
  }

  /// 发送活动申请推送
  Future<bool> sendActivityRequestMessage({
    required String targetUserId,
    required String activityTitle,
    required String userName,
  }) async {
    try {
      developer.log('📤 发送活动申请推送');
      
      return await sendTextMessage(
        targetId: targetUserId,
        content: '$userName 申请参加活动：$activityTitle***', // 添加标识符
        conversationType: RCIMIWConversationType.private,
      );
    } catch (e) {
      developer.log('💥 发送活动申请异常: $e');
      return false;
    }
  }

  /// 📝 新增：设置活动申请通知状态（参考MyApplication2的ifInputActivity逻辑）
  void _setActivityApplicationNotification(bool hasNotification) {
    try {
      // 方法1：尝试通过MyIndexController设置（如果已初始化）
      try {
        // 使用Get.isRegistered检查controller是否已注册
        if (Get.isRegistered<MyIndexController>()) {
          final myIndexController = Get.find<MyIndexController>();
          myIndexController.setActivityApplicationNotification(hasNotification);
          developer.log('✅ 通过MyIndexController设置活动申请通知状态: $hasNotification');
          return;
        }
      } catch (e) {
        developer.log('⚠️ MyIndexController未注册或获取失败: $e');
      }
      
      // 方法2：直接保存到本地存储（作为备用方案）
      final storage = GetStorage();
      storage.write('ifInputActivity', hasNotification ? '1' : '0');
      developer.log('📋 活动申请通知状态已直接保存到本地存储: $hasNotification');
      
    } catch (e) {
      developer.log('💥 设置活动申请通知状态异常: $e');
    }
  }

  /// 🔥 设置主页消息通知小黄点状态（带自动修复功能）
  void _setHomeMessageNotification(bool hasMessage) {
    try {
      // 🔥 健康检查：确保HomeController已注册
      if (!Get.isRegistered<HomeController>()) {
        developer.log('⚠️ HomeController未注册，尝试自动修复...', name: 'RongCloud');
        _tryFixHomeControllerRegistration();
      }

      // 再次检查并设置
      if (Get.isRegistered<HomeController>()) {
        final homeController = Get.find<HomeController>();
        homeController.setMessageNotification(hasMessage);
        developer.log('✅ 通过HomeController设置消息通知小黄点: $hasMessage', name: 'RongCloud');
      } else {
        developer.log('❌ HomeController修复失败，仍然无法设置消息通知小黄点', name: 'RongCloud');
        // 🔥 降级方案：记录状态，等待Controller注册后补设
        developer.log('🔄 使用降级方案，等待HomeController注册后补设状态: $hasMessage', name: 'RongCloud');
      }
    } catch (e) {
      developer.log('💥 设置主页消息通知状态异常: $e', name: 'RongCloud');
    }
  }

  /// 🔥 尝试修复HomeController注册问题
  void _tryFixHomeControllerRegistration() {
    try {
      developer.log('🔧 开始尝试修复HomeController注册...', name: 'RongCloud');
      
      // 🔥 方法1：检查MainController是否存在，如果存在说明应用正常运行
      if (Get.isRegistered<MainController>()) {
        developer.log('✅ MainController已注册，说明应用正常运行', name: 'RongCloud');
      } else {
        developer.log('⚠️ MainController也未注册，可能是启动时序问题', name: 'RongCloud');
      }
      
      // 🔥 方法2：直接注册HomeController（使用延迟确保Controller类可用）
      Future.delayed(Duration(milliseconds: 100), () async {
        try {
          if (!Get.isRegistered<HomeController>()) {
            developer.log('🔄 延迟注册HomeController...', name: 'RongCloud');
            
            // 动态导入并注册HomeController
            final homeController = Get.put(HomeController(), permanent: true);
            
            developer.log('✅ HomeController延迟注册成功', name: 'RongCloud');
            
            // 🔥 注册成功后，补设之前错过的通知状态
            if (newMessageUserIds.isNotEmpty) {
              homeController.setMessageNotification(true);
              developer.log('🔄 补设消息通知状态: true', name: 'RongCloud');
            }
          }
        } catch (e) {
          developer.log('💥 延迟注册HomeController异常: $e', name: 'RongCloud');
        }
      });
      
    } catch (e) {
      developer.log('💥 修复HomeController注册异常: $e', name: 'RongCloud');
    }
  }

  /// 🔥 新增：设置加好友消息通知状态（统一管理主页和聊天页面）
  void _setFriendRequestNotification(bool hasNotification) {
    try {
      // 🔥 优先使用NotificationManager统一管理
      if (Get.isRegistered<NotificationManager>()) {
        final notificationManager = Get.find<NotificationManager>();
        notificationManager.setFriendRequestNotification(hasNotification);
        developer.log('✅ 通过NotificationManager统一设置加好友消息通知: $hasNotification');
        return;
      }
      
      // 🔄 降级方案：分别设置两个页面
      developer.log('⚠️ NotificationManager未注册，使用降级方案');
      
      // 设置主页消息通知
      if (Get.isRegistered<HomeController>()) {
        final homeController = Get.find<HomeController>();
        homeController.setMessageNotification(hasNotification);
        developer.log('✅ 通过HomeController设置主页消息通知: $hasNotification');
      }
      
      // 设置聊天页面好友申请通知
      if (Get.isRegistered<MessageIndexController>()) {
        final messageController = Get.find<MessageIndexController>();
        messageController.setFriendRequestNotification(hasNotification);
        developer.log('✅ 通过MessageIndexController设置聊天页面好友申请通知: $hasNotification');
      }
      
    } catch (e) {
      developer.log('💥 设置加好友消息通知状态异常: $e');
      // 最终降级：只设置主页通知
      _setHomeMessageNotification(hasNotification);
    }
  }

  /// 🔥 新增：通知MessageIndexController实时更新（用户在聊天页面时）
  void _notifyMessageIndexControllerUpdate(String userId, int newCount, String content, String senderName) {
    try {
      developer.log('🔄 =============== 通知聊天列表实时更新 ===============');
      developer.log('👤 用户ID: $userId');
      developer.log('🔢 新的消息数量: $newCount');
      developer.log('💬 消息内容: $content');
      
      // 🔥 增强Controller检查逻辑，解决时序问题
      bool controllerFound = false;
      MessageIndexController? messageController;
      
      // 方法1：标准GetX注册检查
      if (Get.isRegistered<MessageIndexController>()) {
        try {
          messageController = Get.find<MessageIndexController>();
          controllerFound = true;
          developer.log('✅ 通过Get.isRegistered找到MessageIndexController');
        } catch (e) {
          developer.log('⚠️ Get.isRegistered返回true但Get.find失败: $e');
        }
      }
      
      // 方法2：静态方法获取（备用方案）
      if (!controllerFound) {
        try {
          messageController = MessageIndexController.getInstance();
          if (messageController != null) {
            controllerFound = true;
            developer.log('✅ 通过静态方法找到MessageIndexController');
          }
        } catch (e) {
          developer.log('⚠️ 静态方法获取Controller失败: $e');
        }
      }
      
      // 方法3：当前路由检查（最终判断）
      if (!controllerFound) {
        final currentRoute = Get.currentRoute;
        developer.log('📍 当前路由: $currentRoute');
        if (currentRoute == '/message_message_index') {
          developer.log('✅ 用户在聊天列表页面，但Controller获取失败，延迟重试');
          // 延迟重试（可能Controller还在初始化中）
          Future.delayed(const Duration(milliseconds: 200), () {
            _notifyMessageIndexControllerUpdate(userId, newCount, content, senderName);
          });
          return;
        }
      }
      
      if (controllerFound && messageController != null) {
        // 调用实时更新方法
        messageController.updateChatItemRealTime(
          userId: userId,
          unreadCount: newCount,
          lastMessage: content,
          senderName: senderName,
        );
        
        developer.log('✅ 已通知MessageIndexController实时更新聊天项: $senderName (数量: $newCount)');
      } else {
        developer.log('⚠️ MessageIndexController不可用，用户可能不在聊天页面');
        developer.log('📍 当前路由: ${Get.currentRoute}');
        developer.log('📊 Get.isRegistered检查: ${Get.isRegistered<MessageIndexController>()}');
      }
      
    } catch (e) {
      developer.log('💥 通知MessageIndexController更新异常: $e');
    }
  }

  /// 🔥 新增：缓存新消息信息（支持消息数量累计）
  void _cacheNewMessage(String userId, String content, String senderName, String senderAvatar) {
    try {
      developer.log('💾 =============== 缓存新消息 ===============');
      developer.log('👤 用户ID: $userId');
      developer.log('👤 发送者: $senderName');
      developer.log('💬 消息内容: $content');
      
      // 1. 添加到新消息用户ID集合中
      newMessageUserIds.add(userId);
      
      // 2. 缓存最新消息详情
      cachedMessages[userId] = {
        'content': content,
        'senderName': senderName,
        'senderAvatar': senderAvatar,
        'timestamp': DateTime.now().millisecondsSinceEpoch,
      };
      
      // 🔥 3. 累计未读消息数量
      final currentCount = unreadMessageCounts[userId] ?? 0;
      final newCount = currentCount + 1;
      unreadMessageCounts[userId] = newCount;
      
      developer.log('💾 消息缓存成功: $senderName');
      developer.log('📊 当前有新消息的用户数: ${newMessageUserIds.length}');
      developer.log('📋 新消息用户列表: ${newMessageUserIds.toList()}');
      developer.log('🔢 用户 $userId 的未读消息数量: $currentCount -> $newCount');
      
      // 🔥 4. 通知MessageIndexController实时更新UI（如果用户在聊天页面）
      _notifyMessageIndexControllerUpdate(userId, newCount, content, senderName);
      
    } catch (e) {
      developer.log('💥 缓存新消息异常: $e');
    }
  }

  /// 🔥 新增：检查用户是否有新消息
  bool hasNewMessage(String userId) {
    try {
      final hasMessage = newMessageUserIds.contains(userId);
      developer.log('🔍 检查用户 $userId 是否有新消息: $hasMessage');
      return hasMessage;
    } catch (e) {
      developer.log('💥 检查新消息异常: $e');
      return false;
    }
  }

  /// 🔥 新增：获取用户的最新消息内容
  Map<String, dynamic>? getLatestMessage(String userId) {
    try {
      final message = cachedMessages[userId];
      if (message != null) {
        developer.log('📨 获取用户 $userId 的最新消息: ${message['content']}');
      }
      return message;
    } catch (e) {
      developer.log('💥 获取最新消息异常: $e');
      return null;
    }
  }

  /// 🔥 新增：获取用户的未读消息数量
  int getUnreadMessageCount(String userId) {
    try {
      final count = unreadMessageCounts[userId] ?? 0;
      developer.log('🔢 获取用户 $userId 的未读消息数量: $count');
      return count;
    } catch (e) {
      developer.log('💥 获取未读消息数量异常: $e');
      return 0;
    }
  }

  /// 🔥 新增：清除指定用户的新消息缓存（进入聊天页面时调用）
  void clearUserNewMessage(String userId) {
    try {
      developer.log('🗑️ =============== 清除用户新消息缓存 ===============');
      developer.log('👤 用户ID: $userId');
      
      final hadMessage = newMessageUserIds.contains(userId);
      final previousCount = unreadMessageCounts[userId] ?? 0;
      
      // 从新消息用户ID集合中移除
      newMessageUserIds.remove(userId);
      
      // 从消息详情缓存中移除
      cachedMessages.remove(userId);
      
      // 🔥 从消息数量缓存中移除
      unreadMessageCounts.remove(userId);
      
      developer.log('✅ 用户新消息缓存已清除: $userId (之前${hadMessage ? "有" : "无"}新消息)');
      developer.log('🔢 清除的未读消息数量: $previousCount');
      developer.log('📊 剩余有新消息的用户数: ${newMessageUserIds.length}');
      
    } catch (e) {
      developer.log('💥 清除用户新消息缓存异常: $e');
    }
  }

  /// 🔥 新增：获取所有有新消息的用户ID列表
  List<String> getAllNewMessageUserIds() {
    try {
      final userIds = newMessageUserIds.toList();
      developer.log('📋 获取所有有新消息的用户ID: $userIds');
      return userIds;
    } catch (e) {
      developer.log('💥 获取新消息用户列表异常: $e');
      return [];
    }
  }

  /// 🔥 新增：获取总的未读消息数量
  int getTotalUnreadMessageCount() {
    try {
      final totalCount = unreadMessageCounts.values.fold(0, (sum, count) => sum + count);
      developer.log('🔢 总的未读消息数量: $totalCount');
      return totalCount;
    } catch (e) {
      developer.log('💥 获取总未读消息数量异常: $e');
      return 0;
    }
  }

  /// 🔥 新增：获取所有用户的未读消息详情
  Map<String, int> getAllUnreadMessageCounts() {
    try {
      final counts = Map<String, int>.from(unreadMessageCounts);
      developer.log('📊 所有用户的未读消息数量: $counts');
      return counts;
    } catch (e) {
      developer.log('💥 获取所有未读消息数量异常: $e');
      return {};
    }
  }

  /// 🔥 新增：清除所有新消息缓存
  void clearAllNewMessages() {
    try {
      developer.log('🗑️ 清除所有新消息缓存');
      final count = newMessageUserIds.length;
      final totalMessages = unreadMessageCounts.values.fold(0, (sum, count) => sum + count);
      
      newMessageUserIds.clear();
      cachedMessages.clear();
      unreadMessageCounts.clear(); // 🔥 清除消息数量缓存
      
      developer.log('✅ 已清除 $count 个用户的新消息缓存（共 $totalMessages 条消息）');
      
    } catch (e) {
      developer.log('💥 清除所有新消息缓存异常: $e');
    }
  }

  /// 🔥 新架构：添加消息到用户列表（统一消息管理）
  void addMessageToUser({
    required String userId,
    required String content,
    required bool isMe,
    DateTime? timestamp,
    String? messageId,
    String? senderName,
    String? senderAvatar,
    String? messageType, // 🔥 新增：消息类型（chat, friend_request, activity_request）
  }) {
    try {
      developer.log('📝 =============== 添加消息到用户列表 ===============');
      developer.log('👤 用户ID: $userId');
      developer.log('💬 消息内容: $content');
      developer.log('👤 是否是我发送: $isMe');
      developer.log('👤 发送者: ${senderName ?? (isMe ? "我" : "对方")}');
      
      // 确保用户消息列表存在
      if (!userMessages.containsKey(userId)) {
        userMessages[userId] = <Map<String, dynamic>>[].obs;
        developer.log('✅ 为用户 $userId 创建新的消息列表');
      }
      
      // 创建消息对象
      final messageData = {
        'content': content,
        'isMe': isMe,
        'timestamp': (timestamp ?? DateTime.now()).millisecondsSinceEpoch,
        'sender': isMe ? "1" : "2",
        'messageIfRead': "1",
        'messageId': messageId ?? DateTime.now().millisecondsSinceEpoch.toString(),
        'senderName': senderName ?? (isMe ? "我" : "对方"),
        'senderAvatar': senderAvatar ?? '',
        'messageType': messageType ?? 'chat', // 🔥 新增：消息类型，默认为普通聊天
      };
      
      // 检查是否重复（根据时间戳和内容去重）
      final userMsgList = userMessages[userId]!;
      final isDuplicate = userMsgList.any((msg) => 
        msg['content'] == content && 
        msg['isMe'] == isMe &&
        ((msg['timestamp'] as int) - (messageData['timestamp'] as int)).abs() < 5000
      );
      
      if (!isDuplicate) {
        userMsgList.add(messageData);
        
        // 按时间排序（保持消息顺序）
        userMsgList.sort((a, b) => (a['timestamp'] as int).compareTo(b['timestamp'] as int));
        
        // 🔥 限制消息数量（避免内存过大）
        if (userMsgList.length > 200) {
          final removeCount = userMsgList.length - 200;
          userMsgList.removeRange(0, removeCount);
          developer.log('🗑️ 用户 $userId 消息列表超过200条，已清理旧消息');
        }
        
        developer.log('✅ 消息已添加到用户 $userId 列表，当前消息数: ${userMsgList.length}');
        
        // 🔥 同时保存到本地存储（备份机制）
        _saveMessageToLocalStorage(userId, messageData);
        
      } else {
        developer.log('⚠️ 消息重复，跳过添加: $content');
      }
      
    } catch (e) {
      developer.log('💥 添加消息到用户列表异常: $e');
    }
  }
  
  /// 🔥 新架构：获取用户消息列表（供聊天页面观察）
  RxList<Map<String, dynamic>>? getUserMessages(String userId) {
    try {
      if (!userMessages.containsKey(userId)) {
        userMessages[userId] = <Map<String, dynamic>>[].obs;
        developer.log('✅ 为用户 $userId 创建新的消息列表');
        
        // 🔥 从本地存储加载历史消息
        _loadUserMessagesFromLocal(userId);
      }
      
      return userMessages[userId];
    } catch (e) {
      developer.log('💥 获取用户消息列表异常: $e');
      return null;
    }
  }
  
  /// 🔥 新架构：从本地存储加载用户消息
  void _loadUserMessagesFromLocal(String userId) {
    try {
      developer.log('💾 从本地存储加载用户 $userId 的历史消息');
      
      final storage = GetStorage();
      final chatKey = 'chat_history_$userId';
      final chatHistoryJson = storage.read<List>(chatKey) ?? [];
      
      if (chatHistoryJson.isNotEmpty) {
        final userMsgList = userMessages[userId]!;
        
        for (final jsonData in chatHistoryJson) {
          try {
            final msgMap = Map<String, dynamic>.from(jsonData);
            
            // 转换时间戳格式
            if (msgMap['timestamp'] is String) {
              final timestamp = DateTime.tryParse(msgMap['timestamp']);
              if (timestamp != null) {
                msgMap['timestamp'] = timestamp.millisecondsSinceEpoch;
              }
            }
            
            // 添加缺失字段
            msgMap['senderName'] = msgMap['senderName'] ?? (msgMap['isMe'] == true ? "我" : "对方");
            msgMap['senderAvatar'] = msgMap['senderAvatar'] ?? '';
            msgMap['messageType'] = msgMap['messageType'] ?? 'chat'; // 🔥 确保消息类型字段存在
            
            userMsgList.add(msgMap);
          } catch (parseError) {
            developer.log('⚠️ 解析本地消息失败: $parseError');
          }
        }
        
        // 按时间排序
        userMsgList.sort((a, b) => (a['timestamp'] as int).compareTo(b['timestamp'] as int));
        
        developer.log('✅ 从本地加载用户 $userId 历史消息: ${userMsgList.length}条');
      }
      
    } catch (e) {
      developer.log('💥 从本地加载用户消息异常: $e');
    }
  }
  
  /// 🔥 新架构：保存消息到本地存储
  void _saveMessageToLocalStorage(String userId, Map<String, dynamic> messageData) {
    try {
      final storage = GetStorage();
      final chatKey = 'chat_history_$userId';
      final chatHistoryList = storage.read<List>(chatKey) ?? [];
      
      // 转换为兼容的JSON格式
      final jsonData = {
        'content': messageData['content'],
        'isMe': messageData['isMe'],
        'timestamp': DateTime.fromMillisecondsSinceEpoch(messageData['timestamp']).toIso8601String(),
        'sender': messageData['sender'],
        'messageIfRead': messageData['messageIfRead'],
        'messageId': messageData['messageId'],
        'messageType': messageData['messageType'] ?? 'chat', // 🔥 保存消息类型
      };
      
      chatHistoryList.add(jsonData);
      
      // 限制历史记录数量
      if (chatHistoryList.length > 200) {
        chatHistoryList.removeRange(0, chatHistoryList.length - 200);
      }
      
      storage.write(chatKey, chatHistoryList);
      
    } catch (e) {
      developer.log('💥 保存消息到本地存储异常: $e');
    }
  }
  
  /// 🔥 新架构：清除用户消息列表
  void clearUserMessages(String userId) {
    try {
      developer.log('🗑️ 清除用户 $userId 的消息列表');
      if (userMessages.containsKey(userId)) {
        userMessages[userId]!.clear();
      }
      
      // 同时清除本地存储
      final storage = GetStorage();
      final chatKey = 'chat_history_$userId';
      storage.remove(chatKey);
      
    } catch (e) {
      developer.log('💥 清除用户消息列表异常: $e');
    }
  }

  /// 🔥 新增：完整的退出登录清理（参考MyApplication2的RongCoreClient.getInstance().logout()）
  Future<void> logoutAndClearAll() async {
    try {
      developer.log('🚀 =============== 融云服务完整退出登录清理 ===============');
      
      // 1. 断开融云连接（参考MyApplication2的RongCoreClient.getInstance().logout()）
      await disconnect();
      developer.log('✅ 融云连接已断开');
      
      // 2. 清除所有消息缓存和状态
      clearAllNewMessages();
      developer.log('✅ 消息缓存已清除');
      
      // 3. 清除好友申请通知状态
      hasPendingFriendRequest.value = false;
      developer.log('✅ 好友申请状态已清除');
      
      // 4. 重置连接状态
      isConnected.value = false;
      isConnecting.value = false;
      developer.log('✅ 连接状态已重置');
      
      // 5. 销毁融云引擎（彻底清理，为下次登录做准备）
      await destroy();
      developer.log('✅ 融云引擎已销毁');
      
      // 6. 重新初始化融云SDK（为下次登录做准备）
      await _initRongCloud();
      developer.log('✅ 融云SDK已重新初始化');
      
      developer.log('🎉 =============== 融云服务退出登录清理完成 ===============');
      
    } catch (e) {
      developer.log('💥 融云服务退出登录清理异常: $e');
      // 即使异常也要确保基本清理
      isConnected.value = false;
      isConnecting.value = false;
      clearAllNewMessages();
      hasPendingFriendRequest.value = false;
    }
  }
  
  /// 获取连接状态字符串
  String getConnectionStatusString() {
    return isConnected.value ? '已连接' : (isConnecting.value ? '连接中' : '未连接');
  }

  /// 🔥 新增：检查是否有待处理的好友申请
  bool hasPendingFriendRequestNotification() {
    try {
      final hasPending = hasPendingFriendRequest.value;
      developer.log('🔍 检查是否有待处理的好友申请: $hasPending');
      return hasPending;
    } catch (e) {
      developer.log('💥 检查好友申请状态异常: $e');
      return false;
    }
  }

  /// 🔥 新增：清除好友申请通知状态（点击好友申请图标时调用）
  void clearPendingFriendRequestNotification() {
    try {
      developer.log('🗑️ =============== 融云服务清除好友申请状态 ===============');
      developer.log('🔍 清除前状态: hasPendingFriendRequest=${hasPendingFriendRequest.value}');
      
      // 🔥 立即清除状态
      hasPendingFriendRequest.value = false;
      developer.log('✅ 融云服务中的好友申请状态已清除: ${hasPendingFriendRequest.value}');
      
      // 🔥 确保状态持久化（避免重启后状态恢复）
      try {
        final storage = GetStorage();
        storage.write('hasPendingFriendRequest', false);
        developer.log('✅ 好友申请状态已持久化到本地存储');
      } catch (storageError) {
        developer.log('⚠️ 本地存储写入失败: $storageError');
      }
      
      developer.log('🏁 =============== 融云服务好友申请状态清除完成 ===============');
    } catch (e) {
      developer.log('💥 清除好友申请状态异常: $e');
      // 🔥 确保异常情况下状态也被重置
      hasPendingFriendRequest.value = false;
    }
  }

  /// 🔥 新增：极光推送详细日志打印方法（集成架构）
  /// 使用NotificationService中集成的极光推送功能
  Future<void> _printJPushDetailedLogs({
    required String senderName,
    required String messageContent,
    String? senderUserId,
  }) async {
    try {
      developer.log('🔍 =============== 调用集成架构极光推送服务 ===============');
      
      // 🔥 使用集成在NotificationService中的极光推送功能
      try {
        if (Get.isRegistered<NotificationService>()) {
          final notificationService = Get.find<NotificationService>();
          developer.log('✅ 使用集成架构（NotificationService中的极光推送）');
          await notificationService.printJPushDetailedLogsForRongCloud(
            senderName: senderName,
            messageContent: messageContent,
            senderUserId: senderUserId,
          );
          developer.log('🎯 集成架构极光推送日志打印完成');
          return;
        }
      } catch (e) {
        developer.log('💥 NotificationService调用异常: $e');
      }
      
      // 🔥 如果NotificationService不可用，输出基本信息
      developer.log('⚠️ NotificationService不可用');
      developer.log('📝 请检查以下配置：');
      developer.log('   1. NotificationService是否已注册？${Get.isRegistered<NotificationService>()}');
      developer.log('   2. 是否已添加jpush_flutter依赖？');
      developer.log('   3. 是否已启用ENABLE_JPUSH_CODE标志？');
      
      // 🔥 输出基本的消息信息
      developer.log('💬 融云消息基本信息:');
      developer.log('   👤 发送者: $senderName');
      developer.log('   📱 发送者ID: $senderUserId');
      developer.log('   💬 消息内容: $messageContent');
      developer.log('   ⏰ 时间: ${DateTime.now().toLocal()}');
      
    } catch (e) {
      developer.log('💥 极光推送服务调用异常: $e');
    } finally {
      developer.log('🔍 =============== 集成架构服务调用完成 ===============');
    }
  }

  @override
  void onClose() {
    // 🔥 关闭消息流控制器
    _messageStreamController.close();
    
    disconnect();
    destroy();
    super.onClose();
  }
}
